//package com.elitel.common.redis.service.impl;
//
//import java.util.HashMap;
//import java.util.Iterator;
//import java.util.List;
//import java.util.Map;
//import java.util.Map.Entry;
//import java.util.Set;
//import java.util.concurrent.TimeUnit;
//
//import org.apache.commons.lang.StringUtils;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.context.annotation.Scope;
//import org.springframework.dao.DataAccessException;
//import org.springframework.dao.InvalidDataAccessApiUsageException;
//import org.springframework.data.redis.connection.RedisConnection;
//import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
//import org.springframework.data.redis.core.RedisCallback;
//import org.springframework.data.redis.core.RedisTemplate;
//import org.springframework.data.redis.core.StringRedisTemplate;
//import org.springframework.data.redis.serializer.RedisSerializer;
//import org.springframework.stereotype.Component;
//import org.springframework.stereotype.Service;
//
//import com.elitel.common.redis.service.RedisCacheService;
//import redis.clients.jedis.Jedis;
//
//@Component
//@Service
//@Scope("prototype")
//@SuppressWarnings("all")
//public class RedisCacheServiceImpl implements RedisCacheService {
//
//    @Autowired
//    private RedisTemplate redisTemplate;
//    @Autowired
//    private StringRedisTemplate stringRedisTemplate;
//    @Autowired
//    private JedisConnectionFactory memoryJedisConnectionFactory;
//
//    /**
//     * 根据业务设置使用的redis库
//     */
//    private boolean setDataIndex(int rdi) {
//        try {
//            memoryJedisConnectionFactory.setDatabase(rdi);
//            return true;
//        } catch (Exception e) {
//            e.printStackTrace();
//            return false;
//        }
//    }
//
//    public RedisSerializer<String> getStringSerializer() {
//        return redisTemplate.getStringSerializer();
//    }
//
//    /**
//     * string保存
//     */
//    public void saveObject(final String key, final String value, int rdi) {
//        setDataIndex(rdi);
//        redisTemplate.execute(new RedisCallback<Boolean>() {
//            public Boolean doInRedis(RedisConnection connection)
//                    throws DataAccessException {
//                try {
//                    RedisSerializer<String> serializer = getStringSerializer();
//                    byte[] bKey = serializer.serialize(key);
//                    byte[] bValue = serializer.serialize(value);
//                    connection.set(bKey, bValue);
//                } finally {
//                    connection.close();
//                }
//                return true;
//            }
//        });
//
//    }
//
//    /***
//     * show 保存redis插入信息
//     * @param key 唯一标识
//     * @param value 数据
//     * @param rdi 数据库序列
//     * @param timeSeconds 过期时间(秒)
//     */
//    @Override
//    public void saveObjectTimeOut(String key, String value, int rdi, long timeSeconds) {
//        setDataIndex(rdi);
//        redisTemplate.execute(new RedisCallback<Boolean>() {
//
//            public Boolean doInRedis(RedisConnection connection)
//                    throws DataAccessException {
//                try {
//                    RedisSerializer<String> serializer = getStringSerializer();
//                    byte[] bKey = serializer.serialize(key);
//                    byte[] bValue = serializer.serialize(value);
//                    connection.set(bKey, bValue);
//                    connection.expire(bKey, timeSeconds);
//                } finally {
//                    connection.close();
//                }
//                return true;
//            }
//        });
//    }
//
//    /**
//     * string获取
//     */
//    public String getObject(final String key, int rdi) {
//        setDataIndex(rdi);
//        String result = (String) redisTemplate
//                .execute(new RedisCallback<String>() {
//
//                    public String doInRedis(RedisConnection connection)
//                            throws DataAccessException {
//                        try {
//                            RedisSerializer<String> serializer = getStringSerializer();
//                            byte[] bKey = serializer.serialize(key);
//                            if (connection.exists(bKey) == true) {
//                                bKey = connection.get(bKey);
//                                String result = serializer.deserialize(bKey);
//                                return result;
//                            } else {
//                                return "";
//                            }
//                        } finally {
//                            connection.close();
//                        }
//                    }
//                });
//        return result;
//    }
//
//    /**
//     * string删除
//     */
//    public boolean delObject(final String key, int rdi) {
//        setDataIndex(rdi);
//        boolean bl = (Boolean) redisTemplate
//                .execute(new RedisCallback<Boolean>() {
//
//                    public Boolean doInRedis(RedisConnection connection)
//                            throws DataAccessException {
//                        try {
//                            RedisSerializer<String> serializer = getStringSerializer();
//                            byte[] bKey = serializer.serialize(key);
//                            if (connection.exists(bKey) == true) {
//                                Long a = connection.del(bKey);
//                                return true;
//                            } else {
//                                return false;
//                            }
//                        } finally {
//                            connection.close();
//                        }
//                    }
//                });
//        return bl;
//    }
//
//    /**
//     * 设置过期时间
//     *
//     * @param key 唯一
//     * @param key 域中唯一key
//     */
//    public boolean setKeyTimeOut(String key, long timeMinutes, int rdi) {
//        setDataIndex(rdi);
//        return redisTemplate.expire(key, timeMinutes, TimeUnit.MINUTES);
//    }
//
//    /**
//     * hash保存
//     *
//     * @param ykey  hash的域key（唯一）
//     * @param key   域中唯一key
//     * @param value 与key关联值
//     */
//    public void saveHObject(final String ykey, final String key,
//                            final String value, int rdi) {
//        setDataIndex(rdi);
//        redisTemplate.execute(new RedisCallback<Boolean>() {
//
//            public Boolean doInRedis(RedisConnection connection)
//                    throws DataAccessException {
//                try {
//                    RedisSerializer<String> serializer = getStringSerializer();
//                    byte[] ybKey = serializer.serialize(ykey);
//                    byte[] bKey = serializer.serialize(key);
//                    byte[] bValue = serializer.serialize(value);
//                    connection.hSet(ybKey, bKey, bValue);
//                } finally {
//                    connection.close();
//                }
//                return true;
//            }
//        });
//    }
//
//    /**
//     * hash获取
//     */
//
//    public String getHObject(final String ykey, final String key,
//                             int rdi) {
//        setDataIndex(rdi);
//        String result = (String) redisTemplate
//                .execute(new RedisCallback<Object>() {
//
//                    public String doInRedis(RedisConnection connection)
//                            throws DataAccessException {
//                        try {
//                            RedisSerializer<String> serializer = getStringSerializer();
//                            byte[] ybKey = serializer.serialize(ykey);
//                            byte[] bKey = serializer.serialize(key);
//                            if (connection.hExists(ybKey, bKey) == true) {
//                                bKey = connection.hGet(ybKey, bKey);
//                                String result = serializer.deserialize(bKey);
//                                return result;
//                            } else {
//                                return "";
//                            }
//                        } finally {
//                            connection.close();
//                        }
//                    }
//                });
//        return result;
//    }
//
//    /**
//     * 删除该域下的所有
//     */
//    @Override
//    public void delHObject(final String ykey, int rdi) {
//        setDataIndex(rdi);
//        redisTemplate.execute(new RedisCallback<Boolean>() {
//
//            public Boolean doInRedis(RedisConnection connection)
//                    throws DataAccessException {
//                try {
//                    RedisSerializer<String> serializer = getStringSerializer();
//                    byte[] ybKey = serializer.serialize(ykey);
//                    connection.del(serializer.serialize(ykey));
//                } finally {
//                    connection.close();
//                }
//                return null;
//            }
//        });
//    }
//
//    /**
//     * 获取该域下的所有key
//     */
//    public Map<String, String> getHObjectAll(final String ykey, int rdi) {
//        setDataIndex(rdi);
//        Map<String, String> map = (Map<String, String>) redisTemplate
//                .execute(new RedisCallback<Map>() {
//
//                    public Map<String, String> doInRedis(
//                            RedisConnection connection)
//                            throws DataAccessException {
//                        RedisSerializer<String> serializer = getStringSerializer();
//                        byte[] ybKey = serializer.serialize(ykey);
//
//                        Map map = connection.hGetAll(ybKey);
//                        Map<String, String> result = new HashMap<String, String>();
//                        Set set = map.entrySet();
//
//                        Iterator i = set.iterator();
//                        while (i.hasNext()) {
//                            Map.Entry<byte[], byte[]> entry = (Entry<byte[], byte[]>) i
//                                    .next();
//                            result.put(serializer.deserialize(entry.getKey()),
//                                    serializer.deserialize(entry.getValue()));
//                            // System.out.println(serializer.deserialize(entry.getKey()));
//                            // System.out.println(serializer.deserialize(entry.getValue()));
//                        }
//
//                        return result;
//                    }
//                });
//        return map;
//    }
//
//    /**
//     * 入栈 （压栈） 后进先出
//     *
//     * @param key
//     * @param value
//     * @return
//     */
//    public Long push(final String key, final String value, int rdi) {
//        setDataIndex(rdi);
//        return stringRedisTemplate.opsForList().leftPush(key, value);
//    }
//
//    /**
//     * 出栈 后进先出（从对尾开始取值，取出后删除）
//     *
//     * @param key 唯一标识
//     * @return String
//     */
//    public String pop(final String key, int rdi) {
//        setDataIndex(rdi);
//        return stringRedisTemplate.opsForList().leftPop(key);
//    }
//
//    /**
//     * 入队 串行队列，顺序入队
//     *
//     * @param key   唯一标识
//     * @param value
//     * @return Long
//     */
//    public Long in(final String key, final String value, int rdi) {
//        setDataIndex(rdi);
//        return stringRedisTemplate.opsForList().rightPush(key, value);
//    }
//
//    /**
//     * 出队 串行队列先近先出（取出时删除，顺序取出）
//     *
//     * @param key
//     * @return
//     */
//    public String out(final String key, int rdi) {
//        setDataIndex(rdi);
//        return stringRedisTemplate.opsForList().leftPop(key);
//    }
//
//    /**
//     * 栈/队列长 获取栈和队列的长度
//     *
//     * @param key
//     * @return
//     */
//    public Long length(final String key, int rdi) {
//        try {
//            setDataIndex(rdi);
//            Long rel = 0L;
//            rel = stringRedisTemplate.opsForList().size(key);
//            return rel;
//        } catch (InvalidDataAccessApiUsageException i) {
//            // TODO 20160812 zhangtao 异常未处理
//            return -1L;
//        }
//    }
//
//    /**
//     * 范围检索 获取一个栈或队列的区间数据
//     *
//     * @param key
//     * @param start 开始位置
//     * @param end   结束为止
//     * @return
//     */
//    public List<String> range(final String key, int start, int end,
//                              int rdi) {
//        setDataIndex(rdi);
//        return stringRedisTemplate.opsForList().range(key, start, end);
//    }
//
//    /**
//     * 精确删除
//     *
//     * @param key   队列key或栈key
//     * @param i     索引
//     * @param value 数据值
//     */
//    public void remove(final String key, long i, final String value,
//                       int rdi) {
//        setDataIndex(rdi);
//        stringRedisTemplate.opsForList().remove(key, i, value);
//    }
//
//    /**
//     * 检索 栈或队列中，根据索引取值（位置）
//     *
//     * @param key
//     * @param index
//     * @return String
//     */
//    public String index(final String key, long index, int rdi) {
//        setDataIndex(rdi);
//        return stringRedisTemplate.opsForList().index(key, index);
//    }
//
//    /**
//     * 置值 栈或队列中，根据索引设置值（位置）
//     *
//     * @param key
//     * @param index
//     * @param value
//     */
//    public void set(final String key, long index, final String value,
//                    int rdi) {
//        setDataIndex(rdi);
//        stringRedisTemplate.opsForList().set(key, index, value);
//    }
//
//    /**
//     * 裁剪 根据传入的开始位置（start）结束位置（end）删除队列或栈中的数据
//     *
//     * @param key   栈或队列
//     * @param start 开始位置
//     * @param end   结束位置
//     */
//    public void trim(final String key, long start, long end, int rdi) {
//        setDataIndex(rdi);
//        stringRedisTemplate.opsForList().trim(key, start, end);
//    }
//
//    public boolean stringExists(final String key, int rdi) {
//        setDataIndex(rdi);
//        boolean result = (Boolean) redisTemplate
//                .execute(new RedisCallback<Boolean>() {
//
//                    public Boolean doInRedis(RedisConnection connection)
//                            throws DataAccessException {
//                        RedisSerializer<String> serializer = getStringSerializer();
//                        byte[] bKey = serializer.serialize(key);
//                        return connection.exists(bKey);
//                    }
//                });
//        return result;
//    }
//
//    public boolean hashExists(final String ykey, final String key,
//                              int rdi) {
//        setDataIndex(rdi);
//        boolean result = (Boolean) redisTemplate
//                .execute(new RedisCallback<Boolean>() {
//
//                    public Boolean doInRedis(RedisConnection connection)
//                            throws DataAccessException {
//                        RedisSerializer<String> serializer = getStringSerializer();
//                        byte[] byKey = serializer.serialize(ykey);
//                        byte[] bKey = serializer.serialize(key);
//                        return connection.hExists(byKey, bKey);
//                    }
//                });
//        return result;
//    }
//
//    /**
//     * 验证redis的连通性
//     * created by guoyanfei on 2019/07/16
//     * 实现方法
//     *
//     * @param redisIp   ip地址
//     * @param redisPort 端口号
//     * @return true or false
//     */
//    @Override
//    public boolean connectRedis(String redisIp, int redisPort, String password) {
//        Jedis jedis = new Jedis(redisIp, redisPort);
//
//        if (!StringUtils.isBlank(password)) {
//            jedis.auth(password);
//        }
//
//        boolean result = false;
//        try {
//            String strping = jedis.ping();
//            if (strping.equals("PONG")) result = true;
//
//        } catch (Exception e) {
//            System.out.println("redis连接失败!");
//        }
//
//        return result;
//    }
//}
